import 'package:flutter/material.dart';
import 'package:get/get.dart';
import '../../../models/thing_model.dart';
import '../../../providers/product_provider.dart';
import '../../../services/theme_service.dart';
import '../../../utils/json_utils.dart';

/// 物模型编辑器控制器
class ThingModelEditorController extends GetxController with GetSingleTickerProviderStateMixin {
  final ProductProvider productProvider = Get.find<ProductProvider>();
  final ThemeService _themeService = Get.find<ThemeService>();
  
  // 标签控制器
  late TabController tabController;
  
  // 当前选中的标签
  final RxInt currentTabIndex = 0.obs;
  
  // 产品ID
  late String productId;
  
  // 物模型数据
  final Rx<ThingModel?> thingModel = Rx<ThingModel?>(null);
  
  // 加载状态
  final RxBool isLoading = true.obs;
  final RxBool isSaving = false.obs;
  
  // 错误状态
  final RxBool hasError = false.obs;
  final RxString errorMessage = ''.obs;
  
  // 物模型JSON数据
  final RxList<Map<String, dynamic>> properties = <Map<String, dynamic>>[].obs;
  final RxList<Map<String, dynamic>> services = <Map<String, dynamic>>[].obs;
  final RxList<Map<String, dynamic>> events = <Map<String, dynamic>>[].obs;
  
  @override
  void onInit() {
    super.onInit();
    tabController = TabController(length: 3, vsync: this);
    tabController.addListener(() {
      currentTabIndex.value = tabController.index;
    });
    
    // 从参数中获取产品ID
    final args = Get.arguments as Map<String, dynamic>;
    productId = args['productId'] as String;
    
    // 初始化测试数据
    _initTestData();
    
    // 加载物模型数据
    loadThingModel();
  }
  
  @override
  void onClose() {
    tabController.dispose();
    super.onClose();
  }
  
  // 初始化测试数据
  void _initTestData() {
    // 添加测试属性数据
    properties.assignAll([
      {
        'id': 'prop_1',
        'identifier': 'temperature',
        'name': '温度',
        'dataType': 'float',
        'accessMode': 'r',
        'description': '环境温度',
        'unit': '℃'
      },
      {
        'id': 'prop_2',
        'identifier': 'humidity',
        'name': '湿度',
        'dataType': 'float',
        'accessMode': 'r',
        'description': '环境湿度',
        'unit': '%RH'
      }
    ]);
    
    // 添加测试服务数据
    services.assignAll([
      {
        'id': 'srv_1',
        'identifier': 'reboot',
        'name': '重启设备',
        'description': '远程重启设备',
        'input': [],
        'output': [
          {
            'identifier': 'result',
            'name': '执行结果',
            'dataType': 'boolean'
          }
        ]
      }
    ]);
    
    // 添加测试事件数据
    events.assignAll([
      {
        'id': 'evt_1',
        'identifier': 'alarmHigh',
        'name': '高温告警',
        'type': 'alert',
        'description': '温度超过设定阈值',
        'params': [
          {
            'identifier': 'temperature',
            'name': '当前温度',
            'dataType': 'float'
          },
          {
            'identifier': 'threshold',
            'name': '阈值',
            'dataType': 'float'
          }
        ]
      }
    ]);
  }
  
  // 加载物模型数据
  Future<void> loadThingModel() async {
    isLoading.value = true;
    hasError.value = false;
    
    try {
      // TODO: 加载真实数据
      await Future.delayed(const Duration(seconds: 1));
      
      // 此处暂时使用初始化的测试数据
    } catch (e) {
      hasError.value = true;
      errorMessage.value = '加载物模型失败：${e.toString()}';
    } finally {
      isLoading.value = false;
    }
  }
  
  // 保存物模型数据
  Future<bool> saveThingModel() async {
    isSaving.value = true;
    
    try {
      // 构建物模型数据
      final Map<String, dynamic> modelData = {
        'properties': properties,
        'services': services,
        'events': events
      };
      
      // TODO: 调用API保存数据
      await Future.delayed(const Duration(seconds: 1));
      
      // 显示保存成功
      Get.snackbar(
        '成功', 
        '物模型保存成功',
        snackPosition: SnackPosition.BOTTOM
      );
      
      isSaving.value = false;
      return true;
    } catch (e) {
      isSaving.value = false;
      hasError.value = true;
      errorMessage.value = '保存物模型失败: $e';
      
      Get.snackbar(
        '失败', 
        '保存物模型失败: $e',
        snackPosition: SnackPosition.BOTTOM
      );
      
      return false;
    }
  }
  
  // 获取物模型完整数据
  Map<String, dynamic> getModelJson() {
    return {
      'properties': properties,
      'services': services,
      'events': events
    };
  }
  
  // 添加属性
  void addProperty() {
    final id = 'prop_${DateTime.now().millisecondsSinceEpoch}';
    properties.add({
      'id': id,
      'identifier': 'property_${properties.length + 1}',
      'name': '新属性${properties.length + 1}',
      'dataType': 'string',
      'accessMode': 'rw',
      'description': '属性描述'
    });
  }
  
  // 更新属性
  void updateProperty(int index, Map<String, dynamic> property) {
    if (index >= 0 && index < properties.length) {
      properties[index] = property;
      properties.refresh();
    }
  }
  
  // 删除属性
  void deleteProperty(String propId) {
    properties.removeWhere((prop) => prop['id'] == propId);
  }
  
  // 添加服务
  void addService() {
    final id = 'srv_${DateTime.now().millisecondsSinceEpoch}';
    services.add({
      'id': id,
      'identifier': 'service_${services.length + 1}',
      'name': '新服务${services.length + 1}',
      'description': '服务描述',
      'input': [],
      'output': []
    });
  }
  
  // 更新服务
  void updateService(int index, Map<String, dynamic> service) {
    if (index >= 0 && index < services.length) {
      services[index] = service;
      services.refresh();
    }
  }
  
  // 删除服务
  void deleteService(String serviceId) {
    services.removeWhere((service) => service['id'] == serviceId);
  }
  
  // 添加事件
  void addEvent() {
    final id = 'evt_${DateTime.now().millisecondsSinceEpoch}';
    events.add({
      'id': id,
      'identifier': 'event_${events.length + 1}',
      'name': '新事件${events.length + 1}',
      'type': 'info',
      'description': '事件描述',
      'params': []
    });
  }
  
  // 更新事件
  void updateEvent(int index, Map<String, dynamic> event) {
    if (index >= 0 && index < events.length) {
      events[index] = event;
      events.refresh();
    }
  }
  
  // 删除事件
  void deleteEvent(String eventId) {
    events.removeWhere((event) => event['id'] == eventId);
  }
  
  // 获取可用的数据类型选项
  List<String> getDataTypeOptions() {
    return ['string', 'integer', 'float', 'boolean', 'enum', 'date', 'array', 'object'];
  }
  
  // 获取主题颜色
  Color getPrimaryColor() {
    return _themeService.isDarkMode ? Colors.blueAccent : Colors.blue;
  }
  
  // 从JSON字符串导入物模型数据
  void importFromJson(String jsonString) {
    try {
      // 使用JsonUtils解析可能包含转义字符的JSON字符串
      final Map<String, dynamic> data = JsonUtils.parseEscapedJsonString(jsonString);
      
      // 清空现有数据
      properties.clear();
      services.clear();
      events.clear();
      
      // 导入属性
      if (data.containsKey('properties') && data['properties'] is List) {
        final List<dynamic> props = data['properties'];
        for (var prop in props) {
          final String id = 'prop_${DateTime.now().millisecondsSinceEpoch}_${properties.length}';
          
          // 转换属性数据，将desc转为description以匹配编辑器数据格式
          final Map<String, dynamic> property = Map<String, dynamic>.from(prop);
          if (property.containsKey('desc') && !property.containsKey('description')) {
            property['description'] = property['desc'];
          }
          
          // 确保有ID字段用于编辑和删除操作
          property['id'] = id;
          
          // 将数字类型的accessMode转换为字符串(1->r, 2->rw)
          if (property['accessMode'] is int) {
            int accessMode = property['accessMode'];
            property['accessMode'] = accessMode == 1 ? 'r' : 'rw';
          }
          
          properties.add(property);
        }
      }
      
      // 导入服务
      if (data.containsKey('services') && data['services'] is List) {
        final List<dynamic> svcs = data['services'];
        for (var svc in svcs) {
          final String id = 'srv_${DateTime.now().millisecondsSinceEpoch}_${services.length}';
          
          // 转换服务数据，将desc转为description以匹配编辑器数据格式
          final Map<String, dynamic> service = Map<String, dynamic>.from(svc);
          if (service.containsKey('desc') && !service.containsKey('description')) {
            service['description'] = service['desc'];
          }
          
          // 确保有ID字段用于编辑和删除操作
          service['id'] = id;
          
          services.add(service);
        }
      }
      
      // 导入事件
      if (data.containsKey('events') && data['events'] is List) {
        final List<dynamic> evts = data['events'];
        for (var evt in evts) {
          final String id = 'evt_${DateTime.now().millisecondsSinceEpoch}_${events.length}';
          
          // 转换事件数据，将desc转为description以匹配编辑器数据格式
          final Map<String, dynamic> event = Map<String, dynamic>.from(evt);
          if (event.containsKey('desc') && !event.containsKey('description')) {
            event['description'] = event['desc'];
          }
          
          // 将数字类型的type转换为字符串(1->info, 2->alert, 3->error)
          if (event['type'] is int) {
            int type = event['type'];
            switch (type) {
              case 1:
                event['type'] = 'info';
                break;
              case 2:
                event['type'] = 'alert';
                break;
              case 3:
                event['type'] = 'error';
                break;
              default:
                event['type'] = 'info';
            }
          }
          
          // 确保有ID字段用于编辑和删除操作
          event['id'] = id;
          
          // 处理事件参数，有些事件使用output字段存储参数
          if (!event.containsKey('params') && event.containsKey('output')) {
            event['params'] = event['output'];
          }
          
          events.add(event);
        }
      }
      
      // 更新所有观察变量
      properties.refresh();
      services.refresh();
      events.refresh();
      
      // 显示成功消息
      Get.snackbar(
        '成功', 
        '物模型数据已导入',
        snackPosition: SnackPosition.BOTTOM
      );
      
    } catch (e) {
      // 显示错误消息
      hasError.value = true;
      errorMessage.value = 'JSON解析错误: $e';
      
      Get.snackbar(
        '导入失败', 
        'JSON解析错误: $e',
        snackPosition: SnackPosition.BOTTOM,
        backgroundColor: Colors.red.shade100,
        colorText: Colors.red.shade900,
        duration: const Duration(seconds: 5)
      );
    }
  }
  
  // 格式化JSON字符串，使其更易阅读
  String formatJsonString(dynamic json) {
    return JsonUtils.formatJsonString(json);
  }
  
  // 更改标签页
  void changeTab(int index) {
    tabController.animateTo(index);
  }
} 